public class Demo {
    //1.创建线程的方法：创建一个子类，继承Thread，重写run，调用start
    //定义一个继承自Thread的内部类
    //Thread：操作这个类，就相当于在操作操作系统的api
    static class MyThread1 extends Thread{//具名类：有自己的名字
        //重写run方法
        //run描述了一个线程要执行啥样的逻辑，是线程的入口
        @Override
        public void run() {
            System.out.println("hello Thread");
        }
    }

    public static void main1(String[] args) {
        //创建线程对象
        Thread thread =new MyThread1();
        //启动线程
        /*
        start方法是调用系统api，真正在操作系统内部创建一个线程，这个新的线程就会以run作为入
        口方法（就是执行run中的逻辑），所以run方法不需要在代码中显式调用，因为一旦使用start创
        建好了线程，会自动进入入口
         */
        thread.start();
        /*
        如果写成：
        thread.run();
        虽然也能打印hello Thread，但是没有创建新的线程，而是直接在main方法所在的“主线程”中执行了run的逻辑
         */
    }

    //看看单单只有主线程执行与多线程执行的区别
    static class MyThread2 extends Thread{
        @Override
        public void run() {
            while(true){
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);//sleep是Thread的静态方法，休眠1000毫秒
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);//不能在run方法后面throws，因为run是重写，要是加上throws，与父类Thread
                                                  //里面的run方法不一样了，就不能构成重写
                }
            }
        }
    }

    public static void main2(String[] args) throws InterruptedException {
        //创建线程对象
        Thread thread=new MyThread2();
        //启动线程
        thread.start();

        while(true){
            System.out.println("helllo main");
            Thread.sleep(1000);
        }
    }
/*
以上可以看出，hello thread与hello main交替打印
若是把thread.start()换成thread.run()，就只会打印hello thread
*/



////2.创建线程的方法：创建子类，实现Runnable接口，重写run方法，搭配Thread对象进行start
//    class Myrunnable implements Runnable{
//        @Override
//        public void run(){
//            while(true){
//                System.out.println("hello Runnable");
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//        }
//    }/*
//    内部类访问问题：MyRunnable 是一个非静态内部类（实例内部类）在 main 静态方法中无法直接创建非静态内部类的实例，所以这里不能放在这，见demo2
//    */
//    public static void main3(String[] args) throws InterruptedException {
//        Runnable runnable=new Myrunnable();
//        //Runnable没有start方法，想要启动线程，就要搭配Thread
//        Thread thread=new Thread(runnable);
//        thread.start();
//        while(true) {
//            System.out.println("hello main");
//            Thread.sleep(1000);
//        }
//    }




//3.创建线程的方法：继承Thread，重写run，调用start  见demo2



//4.创建线程的方法：实现Runnable，重写run，搭配Thread调用start 通过匿名内部类  见demo4


//5.基于lambda表达式（最推荐，更简单）  见Demo5

}











